Food Safety Classification Model¶

%%time

# Define the API endpoint and parameters
url = "https://data.cityofchicago.org/resource/cwig-ma7x.json"

# Fetch the total count of records
def get_total_count(url):
    params = {
        "$select": "count(*)"
    }
    response = requests.get(url, params=params)
    data = response.json()
    return int(data[0]['count'])

total_count = get_total_count(url)
print(f"Total number of records available: {total_count:,.0f}")

%%time

# Fetch data and load it into a pandas DataFrame
def fetch_data(url, params):
    response = requests.get(url, params=params)
    data = response.json()
    return pd.DataFrame(data)

# Set the limit parameter equal to the number of available records
params = {
    "$limit": total_count
}

# Fetch the data and load it into a DataFrame
df = fetch_data(url, params)

print(f'Number of records retrieved: {df.shape[0]:,.0f}')

df.head(5)

import nltk
import nltk.corpus  
from nltk.text import Text

# Ensure NLTK resources are downloaded (e.g., tokenizers, corpora)
nltk.download('punkt')

clean_data["comments_tokenized"] = clean_data["comments"].map(lambda x:[nltk.tokenize.word_tokenize(i) for i in x])

nltk.download('stopwords')
from nltk.corpus import stopwords

def clean_tokens(tokens_list):
    cleaned_tokens_list = []
    # Assuming tokens_list is a list of lists
    for tokens in tokens_list:
        # Convert to lower case
        tokens = [token.lower() for token in tokens]
        # Remove stopwords
        stop_words = set(stopwords.words('english'))
        tokens = [token for token in tokens if token not in stop_words]
        # Remove punctuation & numbers (keep only alphabetic tokens)
        tokens = [token for token in tokens if token.isalpha()]
        cleaned_tokens_list.append(tokens)
    return cleaned_tokens_list

# Assuming clean_data['comments_tokenized'] is a list of lists
clean_data['comments_tokenized_clean'] = clean_data['comments_tokenized'].apply(lambda x: clean_tokens(x) if isinstance(x, list) and all(isinstance(lst, list) for lst in x) else [])

from nltk.stem import WordNetLemmatizer
nltk.download('wordnet')

wnl = WordNetLemmatizer()

def flatten_and_lemmatize(tokens_list_of_lists):
    # Flatten the list of lists into a single list
    flattened_list = [token for sublist in tokens_list_of_lists for token in sublist]
    # Lemmatize each token in the flattened list
    lemmatized_tokens = [wnl.lemmatize(token) for token in flattened_list]
    return lemmatized_tokens

# Apply the function to the column that contains a list of lists
clean_data['comments_tokenized_flatten_lemma'] = clean_data['comments_tokenized_clean'].apply(flatten_and_lemmatize)

clean_data.head()

clean_data["results"].unique()

violation = violation[(violation["results"] == "Pass") | (violation["results"] == "Fail")]
violation.groupby("results").count()

violation = violation.groupby("results").sample(n=10000, random_state=1)
violation.reset_index(inplace=True, drop=True)
violation.groupby("results").count()

print(X_train)

%time logreg.fit(X_train_dtm, y_train)

logic_accuracy = metrics.accuracy_score(y_test, y_pred_class)
print(f"Test Accuracy: {logic_accuracy * 100:.1f}%")

print(classification_report(y_test, y_pred_class))

coefs_with_fns_df.sort_values(by='coefficient', ascending=True, inplace=True)
coefs_with_fns_df.head(10)

# train and time the model using X_train_dtm
%time nb.fit(X_train_dtm, y_train)

# calculate accuracy of class predictions
bayes_accuracy = metrics.accuracy_score(y_test, y_pred_class)
print(f"Test Accuracy: {bayes_accuracy * 100:.1f}%")

# calculate precision and recall
print(classification_report(y_test, y_pred_class))

# calculate the confusion matrix
print(metrics.confusion_matrix(y_test, y_pred_class))

coefs_with_fns_df.sort_values(by='log_probability', ascending=False, inplace=True)
coefs_with_fns_df.head(10)

# instantiate a SVM model
svm = SGDClassifier(max_iter=100, tol=None)
# train the model using X_train_dtm
%time svm.fit(X_train_dtm, y_train)
# make class predictions for X_test_dtm
y_pred_class = svm.predict(X_test_dtm)

# calculate accuracy of class predictions
svm_accuracy = metrics.accuracy_score(y_test, y_pred_class)
print(svm_accuracy)

# calculate precision and recall
print(classification_report(y_test, y_pred_class))
# calculate the confusion matrix
print(metrics.confusion_matrix(y_test, y_pred_class))

svm

coefs_with_fns_df.sort_values(by='coefficient', ascending=True, inplace=True)
coefs_with_fns_df.head(10)

from sklearn.pipeline import Pipeline

pipeline = Pipeline(
    [
        ("vect", CountVectorizer()),
        ("clf", LogisticRegression()),
    ]
)
pipeline

from pprint import pprint

from sklearn.model_selection import RandomizedSearchCV

random_search = RandomizedSearchCV(
    estimator=pipeline,
    param_distributions=parameter_grid,
    n_iter=40,
    random_state=0,
    n_jobs=2,
    verbose=1,
)


print("Performing grid search...")
print("Hyperparameters to be evaluated:")
pprint(parameter_grid)

from time import time

t0 = time()
random_search.fit(X_train, y_train)
print(f"Done in {time() - t0:.3f}s")

print("Best parameters combination found:")
best_parameters = random_search.best_estimator_.get_params()
for param_name in sorted(parameter_grid.keys()):
    print(f"{param_name}: {best_parameters[param_name]}")

test_accuracy = random_search.score(X_test, y_test)

print(
    "Accuracy of the best parameters using the inner CV of "
    f"the random search: {random_search.best_score_:.3f}"
)
print(f"Accuracy on test set: {test_accuracy:.3f}")

import plotly.express as px

param_names = [shorten_param(name) for name in parameter_grid.keys()]
labels = {
    "mean_score_time": "CV Score time (s)",
    "mean_test_score": "CV score (accuracy)",
}
fig = px.scatter(
    cv_results,
    x="mean_score_time",
    y="mean_test_score",
    error_x="std_score_time",
    error_y="std_test_score",
    hover_data=param_names,
    labels=labels,
)
fig.update_layout(
    title={
        "text": "trade-off between scoring time and mean test score",
        "y": 0.95,
        "x": 0.5,
        "xanchor": "center",
        "yanchor": "top",
    }
)
fig

import math

column_results = param_names + ["mean_test_score", "mean_score_time"]

transform_funcs = dict.fromkeys(column_results, lambda x: x)

transform_funcs["ngram_range"] = lambda x: x[1]

fig = px.parallel_coordinates(
    cv_results[column_results].apply(transform_funcs),
    color="mean_test_score",
    color_continuous_scale=px.colors.sequential.Viridis_r,
    labels=labels,
)
fig.update_layout(
    title={
        "text": "Parallel coordinates plot of text classifier pipeline",
        "y": 0.99,
        "x": 0.5,
        "xanchor": "center",
        "yanchor": "top",
    }
)
fig

import matplotlib.pyplot as plt

# Classifier names
classifiers = ['Naive Bayes', 'SVM', 'Logistic Regression']

# Corresponding accuracy scores
accuracies = [bayes_accuracy, svm_accuracy, logic_accuracy]

# Creating the enhanced bar plot
plt.figure(figsize=(10, 7))
bars = plt.bar(classifiers, accuracies, color=['skyblue', 'lightgreen', 'salmon'])

# Adding data labels above each bar
for bar in bars:
    yval = bar.get_height()
    plt.text(bar.get_x() + bar.get_width()/2, yval + 0.005, round(yval, 3), ha='center', va='bottom')

plt.xlabel('Classifier')
plt.ylabel('Accuracy Score')
plt.title('Comparison of Text Classifier Accuracies')
plt.ylim(0, 1.05)  # Extend y-axis limit slightly above 1 for better visibility of data labels
plt.yticks([i/10 for i in range(11)])  # Setting y-axis ticks to improve readability
plt.grid(axis='y', linestyle='--', alpha=0.7)  # Adding horizontal gridlines for easier comparison
plt.show()